To illustrate the usefulness of structured exception handling, we need to create a class that will throw an exception under the correct (or one might say exceptional) circumstances. Assume we have created a new C# Console Application project (named SimpleException) that defines two class types (Car and Radio) associated by the “has-a” relationship. The Radio class defines a single method that turns the radio’s power on or off:
class Radio { public void TurnOn(bool on) { if(on) Console.WriteLine("Jamming..."); else Console.WriteLine("Quiet time..."); } }
In addition to leveraging the Radio class via containment/delegation, the Car class (shown below) is defined in such a way that if the user accelerates a Car object beyond a predefined maximum speed (specified using a constant member variable named MaxSpeed), its engine explodes, rendering the Car unusable (captured by a private bool member variable named carIsDead).
Beyond these points, the Car type has a few properties to represent the current speed and a user supplied “pet name,” as well as various constructors to set the state of a new Car object. Here is the complete definition (with code annotations):
class Car { // Constant for maximum speed. public const int MaxSpeed = 100; // Car properties. public int CurrentSpeed {get; set;} public string PetName {get; set;} // Is the car still operational? private bool carIsDead; // A car has-a radio. private Radio theMusicBox = new Radio(); // Constructors. public Car() {} public Car(string name, int speed) { CurrentSpeed = speed; PetName = name; } public void CrankTunes(bool state) { // Delegate request to inner object. theMusicBox.TurnOn(state); } // See if Car has overheated. public void Accelerate(int delta) { if (carIsDead) Console.WriteLine("{0} is out of order...", PetName); else { CurrentSpeed += delta; if (CurrentSpeed > MaxSpeed) { Console.WriteLine("{0} has overheated!", PetName); CurrentSpeed = 0; carIsDead = true; } else Console.WriteLine("=> CurrentSpeed = {0}", CurrentSpeed); } } }
Now, if we implement a Main() method that forces a Car object to exceed the predefined maximum speed (set to 100, in the Car class) as shown here:
static void Main(string[] args) { Console.WriteLine("***** Simple Exception Example *****"); Console.WriteLine("=> Creating a car and stepping on it!"); Car myCar = new Car("Zippy", 20); myCar.CrankTunes(true); for (int i = 0; i < 10; i++) myCar.Accelerate(10); Console.ReadLine(); }
we would see the following output:
***** Simple Exception Example ***** => Creating a car and stepping on it! Jamming... => CurrentSpeed = 30 => CurrentSpeed = 40 => CurrentSpeed = 50 => CurrentSpeed = 60 => CurrentSpeed = 70 => CurrentSpeed = 80 => CurrentSpeed = 90 => CurrentSpeed = 100 Zippy has overheated! Zippy is out of order...
Now that we have a functional Car class, I’ll demonstrate the simplest way to throw an exception. The current implementation of Accelerate() simply displays an error message if the caller attempts to speed up the Car beyond its upper limit.
To retrofit this method to throw an exception if the user attempts to speed up the automobile after it has met its maker, you want to create and configure a new instance of the System.Exception class, setting the value of the read-only Message property via the class constructor. When you wish to send the exception object back to the caller, use the C# throw keyword. Here is the relevant code update to the Accelerate() method:
// This time, throw an exception if the user speeds up beyond MaxSpeed. public void Accelerate(int delta) { if (carIsDead) Console.WriteLine("{0} is out of order...", PetName); else { CurrentSpeed += delta; if (CurrentSpeed >= MaxSpeed) { carIsDead = true; CurrentSpeed = 0; // Use the "throw" keyword to raise an exception. throw new Exception(string.Format("{0} has overheated!", PetName)); } else Console.WriteLine("=> CurrentSpeed = {0}", CurrentSpeed); } }
Before examining how a caller would catch this exception, a few points of interest. First of all, when you are throwing an exception, it is always up to you to decide exactly what constitutes the error in question, and when an exception should be thrown. Here, you are making the assumption that if the program attempts to increase the speed of a Car object that has expired, a System.Exception object should be thrown to indicate the Accelerate() method cannot continue (which may or may not be a valid assumption; this will be a judgment call on your part based on the application you are creating).
Alternatively, you could implement Accelerate() to recover automatically without needing to throw an exception in the first place. By and large, exceptions should be thrown only when a more terminal condition has been met (for example, not finding a necessary file, failing to connect to a database, and the like). Deciding exactly what justifies throwing an exception is a design issue you must always contend with. For our current purposes, assume that asking a doomed automobile to increase its speed is cause to throw an exception.
Because the Accelerate() method now throws an exception, the caller needs to be ready to handle the exception should it occur. When you are invoking a method that may throw an exception, you make use of a try/catch block. Once you have caught the exception object, you are able to invoke the members of the exception object to extract the details of the problem.
What you do with this data is largely up to you. You may wish to log this information to a report file, write the data to the Windows event log, e-mail a system administrator, or display the problem to the end user. Here, you will simply dump the contents to the console window:
// Handle the thrown exception. static void Main(string[] args) { Console.WriteLine("***** Simple Exception Example *****"); Console.WriteLine("=> Creating a car and stepping on it!"); Car myCar = new Car("Zippy", 20); myCar.CrankTunes(true); // Speed up past the car's max speed to // trigger the exception. try { for(int i = 0; i < 10; i++) myCar. Accelerate(10); } catch(Exception e) { Console.WriteLine("\n*** Error! ***"); Console.WriteLine("Method: {0}", e.TargetSite); Console.WriteLine("Message: {0}", e.Message); Console.WriteLine("Source: {0}", e.Source); } // The error has been handled, processing continues with the next statement. Console.WriteLine("\n***** Out of exception logic *****"); Console.ReadLine(); }
In essence, a try block is a section of statements that may throw an exception during execution. If an exception is detected, the flow of program execution is sent to the appropriate catch block. On the other hand, if the code within a try block does not trigger an exception, the catch block is skipped entirely, and all is right with the world. The following output shows a test run of this program.
***** Simple Exception Example *****
=> Creating a car and stepping on it!
Jamming...
=> CurrentSpeed = 30
=> CurrentSpeed = 40
=> CurrentSpeed = 50
=> CurrentSpeed = 60
=> CurrentSpeed = 70
=> CurrentSpeed = 80
=> CurrentSpeed = 90
*** Error! ***
Method: Void Accelerate(Int32)
Message: Zippy has overheated!
Source: SimpleException
***** Out of exception logic *****
As you can see, once an exception has been handled, the application is free to continue on from the point after the catch block. In some circumstances, a given exception may be critical enough to warrant the termination of the application. However, in a good number of cases, the logic within the exception handler will ensure the application can continue on its merry way (although it may be slightly less functional, such as not being able to connect to a remote data source).